Cannot be used in conjunction with the _----_----_ssss_tttt_aaaa_nnnn_dddd_aaaa_rrrr_dddd option.
NNNNUUUUMMMMBBBBEEEERRRRSSSS
The most basic element in _bbbb_cccc is the number. Numbers are arbitrary
precision numbers. This precision is both in the integer part and the
fractional part. All numbers are represented internally in decimal and
all computation is done in decimal. (This version truncates results from
divide and multiply operations.) There are two attributes of numbers,
the length and the scale. The length is the total number of significant
decimal digits in a number and the scale is the total number of decimal
digits after the decimal point. For example:
.000001 has a length of 6 and scale of 6.
1935.000 has a length of 7 and a scale of 3.
VVVVAAAARRRRIIIIAAAABBBBLLLLEEEESSSS
Numbers are stored in two types of variables, simple variables and
arrays. Both simple variables and array variables are named. Names
begin with a letter followed by any number of letters, digits and
underscores. All letters must be lower case. (Full alpha-numeric names
are an extension. In POSIX _bbbb_cccc all names are a single lower case letter.)
The type of variable is clear by the context because all array variable
names will be followed by brackets ([]).
There are four special variables, _ssss_cccc_aaaa_llll_eeee_,,,, _iiii_bbbb_aaaa_ssss_eeee_,,,, _oooo_bbbb_aaaa_ssss_eeee_,,,, and _llll_aaaa_ssss_tttt. _ssss_cccc_aaaa_llll_eeee
defines how some operations use digits after the decimal point. The
default value of _ssss_cccc_aaaa_llll_eeee is 0. _iiii_bbbb_aaaa_ssss_eeee and _oooo_bbbb_aaaa_ssss_eeee define the conversion base
for input and output numbers. The default for both input and output is
base 10. _llll_aaaa_ssss_tttt (an extension) is a variable that has the value of the
last printed number. These will be discussed in further detail where
appropriate. All of these variables may have values assigned to them as
well as used in expressions.
CCCCOOOOMMMMMMMMEEEENNNNTTTTSSSS
Comments in _bbbb_cccc start with the characters _////_**** and end with the characters
_****_////. Comments may start anywhere and appear as a single space in the
input. (This causes comments to delimit other input items. For example,
a comment can not be found in the middle of a variable name.) Comments
include any newlines (end of line) between the start and the end of the
comment.
PPPPaaaaggggeeee 2222
bbbbcccc((((1111)))) bbbbcccc((((1111))))
EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS
The numbers are manipulated by expressions and statements. Since the
language was designed to be interactive, statements and expressions are
executed as soon as possible. There is no "main" program. Instead, code
is executed as it is encountered. (Functions, discussed in detail later,
are defined when encountered.)
A simple expression is just a constant. _bbbb_cccc converts constants into
internal decimal numbers using the current input base, specified by the
variable _iiii_bbbb_aaaa_ssss_eeee. (There is an exception in functions.) The legal values
of _iiii_bbbb_aaaa_ssss_eeee are 2 through 16. Assigning a value outside this range to _iiii_bbbb_aaaa_ssss_eeee
will result in a value of 2 or 16. Input numbers may contain the
characters 0-9 and A-F. (Note: They must be capitals. Lower case
letters are variable names.) Single digit numbers always have the value
of the digit regardless of the value of _iiii_bbbb_aaaa_ssss_eeee. (i.e. A = 10.) For
multi-digit numbers, _bbbb_cccc changes all input digits greater or equal to
ibase to the value of _iiii_bbbb_aaaa_ssss_eeee-1. This makes the number _FFFF_FFFF_FFFF always be the
largest 3 digit number of the input base.
Full expressions are similar to many other high level languages. Since
there is only one kind of number, there are no rules for mixing types.
Instead, there are rules on the scale of expressions. Every expression
has a scale. This is derived from the scale of original numbers, the
operation performed and in many cases, the value of the variable _ssss_cccc_aaaa_llll_eeee.
Legal values of the variable _ssss_cccc_aaaa_llll_eeee are 0 to the maximum number
representable by a C integer.
In the following descriptions of legal expressions, "expr" refers to a
complete expression and "var" refers to a simple or an array variable. A
simple variable is just a
_n_a_m_e
and an array variable is specified as
_n_a_m_e[_e_x_p_r]
Unless specifically mentioned the scale of the result is the maximum
scale of the expressions involved.
- expr
The result is the negation of the expression.
++ var
The variable is incremented by one and the new value is the result
of the expression.
-- var
The variable is decremented by one and the new value is the result
of the expression.
var ++
The result of the expression is the value of the variable and then
the variable is incremented by one.
PPPPaaaaggggeeee 3333
bbbbcccc((((1111)))) bbbbcccc((((1111))))
var --
The result of the expression is the value of the variable and then
the variable is decremented by one.
expr + expr
The result of the expression is the sum of the two expressions.
expr - expr
The result of the expression is the difference of the two
expressions.
expr * expr
The result of the expression is the product of the two expressions.
expr / expr
The result of the expression is the quotient of the two expressions.
The scale of the result is the value of the variable _ssss_cccc_aaaa_llll_eeee.
expr % expr
The result of the expression is the "remainder" and it is computed
in the following way. To compute a%b, first a/b is computed to
_ssss_cccc_aaaa_llll_eeee digits. That result is used to compute a-(a/b)*b to the scale
of the maximum of _ssss_cccc_aaaa_llll_eeee+scale(b) and scale(a). If _ssss_cccc_aaaa_llll_eeee is set to
zero and both expressions are integers this expression is the
integer remainder function.
expr ^ expr
The result of the expression is the value of the first raised to the
second. The second expression must be an integer. (If the second
expression is not an integer, a warning is generated and the
expression is truncated to get an integer value.) The scale of the
result is _ssss_cccc_aaaa_llll_eeee if the exponent is negative. If the exponent is
positive the scale of the result is the minimum of the scale of the
first expression times the value of the exponent and the maximum of
_ssss_cccc_aaaa_llll_eeee and the scale of the first expression. (e.g. scale(a^b) =
min(scale(a)*b, max( _ssss_cccc_aaaa_llll_eeee_,,,, scale(a))).) It should be noted that
expr^0 will always return the value of 1.
( expr )
This alters the standard precedence to force the evaluation of the
expression.
var = expr
The variable is assigned the value of the expression.
var <op>= expr
This is equivalent to "var = var <op> expr" with the exception that
the "var" part is evaluated only once. This can make a difference
if "var" is an array.
PPPPaaaaggggeeee 4444
bbbbcccc((((1111)))) bbbbcccc((((1111))))
Relational expressions are a special kind of expression that always
evaluate to 0 or 1, 0 if the relation is false and 1 if the relation is
true. These may appear in any legal expression. (POSIX bc requires that
relational expressions are used only in if, while, and for statements and
that only one relational test may be done in them.) The relational
operators are
expr1 < expr2
The result is 1 if expr1 is strictly less than expr2.
expr1 <= expr2
The result is 1 if expr1 is less than or equal to expr2.
expr1 > expr2
The result is 1 if expr1 is strictly greater than expr2.
expr1 >= expr2
The result is 1 if expr1 is greater than or equal to expr2.
expr1 == expr2
The result is 1 if expr1 is equal to expr2.
expr1 != expr2
The result is 1 if expr1 is not equal to expr2.
Boolean operations are also legal. (POSIX _bbbb_cccc does NOT have boolean
operations). The result of all boolean operations are 0 and 1 (for false
and true) as in relational expressions. The boolean operators are:
!expr
The result is 1 if expr is 0.
expr && expr
The result is 1 if both expressions are non-zero.
expr || expr
The result is 1 if either expression is non-zero.
The expression precedence is as follows: (lowest to highest)
|| operator, left associative
&& operator, left associative
! operator, nonassociative
Relational operators, left associative
Assignment operator, right associative
+ and - operators, left associative
*, / and % operators, left associative
^ operator, right associative
unary - operator, nonassociative
++ and -- operators, nonassociative
PPPPaaaaggggeeee 5555
bbbbcccc((((1111)))) bbbbcccc((((1111))))
This precedence was chosen so that POSIX compliant _bbbb_cccc programs will run
correctly. This will cause the use of the relational and logical
operators to have some unusual behavior when used with assignment
expressions. Consider the expression:
a = 3 < 5
Most C programmers would assume this would assign the result of "3 < 5"
(the value 1) to the variable "a". What this does in _bbbb_cccc is assign the
value 3 to the variable "a" and then compare 3 to 5. It is best to use
parenthesis when using relational and logical operators with the
assignment operators.
There are a few more special expressions that are provided in _bbbb_cccc. These
have to do with user defined functions and standard functions. They all
appear as "_n_a_m_e_((((_p_a_r_a_m_e_t_e_r_s_))))". See the section on functions for user
